module klang.klang.转换工厂.实例化代码.实例化访问.实例化访问_;
import 全局;
import std.conv: ·to = to;
import std.functional: ·fd = toDelegate;
import ··Klang节点_ = klang.klang.语法节点.Klang节点_;
import ··klang类型_ = klang.klang.类型.klang类型_;
import klang.编译.核心.核心_: 词典_, 整数_, 创建数组, 创建词典, 返回零值, 映射, 循环每个, 最小, 获取正规文件名函数_, 查找索引, 结尾包含, 文本包含, 按字符分割, 部分, 连接, 从后查找字符索引;
import klang.编译.工具.工具_: getParseTreeNode_1, 获取节点的源文件, 创建符号表;
import klang.编译.类型.类型_: 基础类型_ = 类型_, 基础符号_ = 符号_, 源映射范围_, 三元结果_, 符号表_;
import klang.klang.类型.klang类型_: 类型_ = Klang类型_, 符号_ = Klang符号_, 签名_ = Klang签名_, KSK, 编译选项_, 节点标志_, 节点扩展_, 类型映射_, 类型标志_, Klang输出种类_, Klang打印选项_, 符号标志_, 复合标志_, klang解析的模块名称_, 内置类型_, 内部符号名_, 节点检查标志_, 签名标志_, 新建匿名类型;
import klang.编译.语法节点.节点_: 基础节点_ = 节点_, 基础源文件_ = 源文件_, 节点数组_;
import klang.klang.语法节点.Klang节点_: 节点_ = Klang节点_, 源文件_ = Klang源文件_, 标识符_ = Klang标识符_, 签名声明_, 对象声明_, 结构声明_, 接口声明_, 类型声明_, 表达式包含类型实参_, 变量声明_, 变量声明列表_, 变量语句_, 属性声明_, 方法声明_, 构建声明_, 释放声明_, 形参声明_, 函数声明_, 继承子句_, 类型引用_, 限定名_, 修饰符_, 测试单元语句_, 调用表达式_, 新建表达式_, 返回语句_, 断言语句_, 块_, 版本语句_, 表达式语句_, 如果语句_, 类型引用节点_ = 类型引用_;
import klang.klang.节点工厂.Klang工厂_: 节点工厂标志_, 节点工厂_ = Klang节点工厂_;
import klang.klang.检查.klang检查_: Klang转换支持_, 全局对象类型, combineTypeMappers;
import klang.klang.转换工厂.名称碎裂.Mangler_: Mangler, OutBuffer;
import klang.klang.转换工厂.实例化代码.类型.实例化使用类型_: 实例化引用标志_, 实例化引用_, 类型打印标志_, 类型打印环境_, 未整合的源文件_;
import klang.klang.转换工厂.实例化代码.工具.工具_: 根据符号更新修饰符, 获取合成节点扩展, 计算名称碎裂部件, 获取节点文本Id, 访问节点数组, 获取节点扩展, 设置源映射, 获取符号名, 实例化类型, 打印类型, 返回空;
import klang.klang.转换工厂.实例化代码.中间码_: 项目声明的符号集合, 未整合的泛型源文件, fc, K;
dstring 当前类型名;
类型映射_ 当前映射;
类型_ 当前类型;
源文件_ 当前源文件;
基础节点_[] 当前属性组;
基础节点_[] 虚表语句组;
基础节点_[] 构建及释放声明组;
基础节点_[] 变量声明组;
基础节点_[] 当前语句组;
形参声明_[] 当前形参声明组;
符号表_ 当前局部符号表;
类型打印环境_ 当前打印环境;
未整合的源文件_ 当前未整合的源文件;
bool 不设置当前块 = false;
bool 应该结束当前块 = false;
bool 返回本体 = false;
void 初始当前打印环境(类型打印环境_ 打印环境) {
    .当前打印环境 = 打印环境;
}
基础源文件_ 获取节点源文件(基础节点_ n) {
    n = getParseTreeNode_1(n);
    return 获取节点的源文件(n);
}
void 实例化类型访问(类型_ t, 类型打印环境_ 打印环境) {
    dstring 储存当前类型名 = .当前类型名;
    .当前类型名 = t.实例化名称;
    基础节点_[] 储存当前语句组 = .当前语句组;
    源文件_ 储存当前源文件 = .当前源文件;
    类型映射_ 储存当前映射 = cast(类型映射_)(.当前映射);
    类型_ 储存当前类型 = .当前类型;
    基础节点_[] 储存当前属性组 = .当前属性组;
    基础节点_[] 储存虚表语句组 = .虚表语句组;
    基础节点_[] 储存构建及释放声明组 = .构建及释放声明组;
    基础节点_[] 储存变量声明组 = .变量声明组;
    符号表_ 储存当前局部符号表 = .当前局部符号表;
    .当前打印环境 = 打印环境;
    符号_ 符号 = (cast(符号_)(t.符号));
    节点_ 值声明 = (cast(节点_)(符号.值声明));
    .当前源文件 = (cast(源文件_)(.获取节点源文件(值声明)));
    未整合的源文件_ 储存未整合的源文件 = 当前打印环境.未整合的源文件;
    .当前未整合的源文件 = 当前打印环境.未整合的源文件;
    if ((当前打印环境.标志 & 类型打印标志_.泛型实例化_) != 0) {
        dstring 源文件id = 获取节点文本Id(.当前源文件);
        if (!未整合的泛型源文件.源文件组内索引.具有(源文件id)) {
            未整合的泛型源文件.源文件组内索引.p·设置(源文件id, 未整合的泛型源文件.整合的文件.length);
            .追加!(源文件_)(未整合的泛型源文件.整合的文件, .当前源文件);
        }
        当前打印环境.未整合的源文件 = 未整合的泛型源文件;
        .当前未整合的源文件 = 未整合的泛型源文件;
    }
    if (t.映射 !is ··null!(类型映射_)) {
        .当前映射 = t.映射;
    }
    .当前类型 = K.解析类型成员组(t);
    .当前属性组 = 创建数组!(基础节点_)();
    .虚表语句组 = 创建数组!(基础节点_)();
    .构建及释放声明组 = 创建数组!(基础节点_)();
    .变量声明组 = 创建数组!(基础节点_)();
    .当前语句组 = 当前未整合的源文件.语句组;
    .当前局部符号表 = 当前未整合的源文件.源文件的符号表;
    .实例化类型声明(值声明);
    当前打印环境.未整合的源文件 = 储存未整合的源文件;
    .当前未整合的源文件 = 当前打印环境.未整合的源文件;
    .当前属性组 = 储存当前属性组;
    .虚表语句组 = 储存虚表语句组;
    .构建及释放声明组 = 储存构建及释放声明组;
    .变量声明组 = 储存变量声明组;
    .当前类型 = 储存当前类型;
    .当前映射 = cast(类型映射_)(储存当前映射);
    .当前源文件 = 储存当前源文件;
    .当前语句组 = 储存当前语句组;
    .当前类型名 = 储存当前类型名;
    .当前局部符号表 = 储存当前局部符号表;
}
void 实例化类型声明(节点_ n) {
    switch (n.目标种类) {
        case KSK.对象声明: {
            return .访问对象声明((cast(对象声明_)(n)));
        }
        case KSK.结构声明: {
            return .访问结构声明((cast(结构声明_)(n)));
        }
        case KSK.类型声明: {
            return .访问类型声明((cast(类型声明_)(n)));
        }
        case KSK.接口声明: {
            return .访问接口声明((cast(接口声明_)(n)));
        }
        case KSK.函数声明: {
            return .访问函数声明((cast(函数声明_)(n)));
        }
        default: break;
    }
}
void 实例化全局变量声明(变量声明_ n) {
    符号_ 符号 = (cast(符号_)(n.符号));
    类型_ 类型 = 符号.类型;
    节点_ TN = .实例化(类型);
    Mangler m = new Mangler();
    m.碎裂变量声明(符号);
    dstring chs = m.outString();
    dstring name = "\\01"d ~ chs;
    实例化引用_ TZ = .获取或初始引用实例(name);
    TZ.引用标志 |= 实例化引用标志_.变量声明_ | 实例化引用标志_.变量定义_;
    标识符_ 名称 = .更新!(标识符_)(fc.创建文本标识符(name), n.名称);
    节点数组_!(修饰符_) 修饰符 = 根据符号更新修饰符(符号);
    ··Klang节点_.Klang令牌_!(KSK) 声明修饰符 = fc.转为令牌(KSK.声明_);
    节点数组_!(修饰符_) 新修饰符组 = 修饰符;
    if ((修饰符 !is null) && (修饰符.原型 !is ··null!(修饰符_[]))) {
        修饰符_[] 声明组 = [(cast(修饰符_)(声明修饰符))];
        .追加!(修饰符_)(声明组, 修饰符.原型);
        新修饰符组 = fc.f·创建节点数组!(修饰符_)(声明组, false);
    }
    else {
        新修饰符组 = fc.f·创建节点数组!(修饰符_)([(cast(修饰符_)(声明修饰符))], false);
    }
    变量声明_ xdec = fc.创建变量声明(名称, TN);
    TZ.变量声明语句 = fc.创建变量声明语句(xdec, 新修饰符组);
    TZ.引用标志 |= 实例化引用标志_.变量声明_;
    项目声明的符号集合.p·设置(name, TZ);
    变量声明_ xn = .更新!(变量声明_)(fc.创建变量声明(名称, .更新!(节点_)(TN, n.类型)), n);
    xn.符号 = 符号;
    TZ.变量定义语句 = fc.创建变量声明语句(xn, 修饰符);
    .追加!(基础节点_)(当前未整合的源文件.变量声明组, TZ.变量定义语句);
    TZ.引用标志 &= ~实例化引用标志_.站位符_;
    当前未整合的源文件.文件内存在的.p·设置(name, TZ.引用标志);
}
void 实例化测试单元(测试单元语句_ n) {
    节点扩展_ links = 获取节点扩展(n);
    if (links.计算的版本表达式 == 三元结果_.真_) {
        基础节点_[] 储存 = .当前语句组;
        .当前语句组 = 创建数组!(基础节点_)();
        访问节点数组!(节点_)(n.语句组, cast(void delegate(节点_))(·fd(&.访问测试单元语句)));
        测试单元语句_ xn = .更新!(测试单元语句_)(fc.创建测试单元语句(fc.f·创建节点数组!(节点_)((cast(节点_[])(.当前语句组)), false), n.版本容器块种类), n);
        .当前语句组 = 储存;
        .追加!(基础节点_)(.当前语句组, xn);
    }
}
void 访问测试单元语句(基础节点_ n) {
}
void 访问函数声明(函数声明_ n) {
    dstring name = 当前类型.实例化名称;
    标识符_ 名称 = .更新!(标识符_)(fc.创建文本标识符(name), n.名称);
    实例化引用_ TZ = .获取或初始引用实例(name);
    TZ.引用标志 |= 实例化引用标志_.函数定义_;
    TZ.类型引用 = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符(name)));
    项目声明的符号集合.p·设置(name, TZ);
    节点扩展_ links = 获取合成节点扩展(TZ.类型引用);
    links.解析类型 = .当前类型;
    TZ.类型名称 = name;
    TZ.碎裂名称 = name;
    TZ.符号 = (cast(符号_)(n.符号));
    基础节点_[] 储存变量声明组 = .变量声明组;
    符号表_ 储存当前局部符号表 = .当前局部符号表;
    形参声明_[] 储存当前形参声明组 = .当前形参声明组;
    .当前局部符号表 = 创建符号表();
    .当前形参声明组 = 创建数组!(形参声明_)();
    签名_ 签名 = 当前类型.当前需要实例化的签名;
    .实例化当前形参(签名, n);
    节点数组_!(形参声明_) 形参组;
    if (当前形参声明组.length > 0) {
        形参组 = fc.f·创建节点数组!(形参声明_)(new 节点数组_!(形参声明_)(.当前形参声明组));
    }
    .当前形参声明组 = 储存当前形参声明组;
    类型_ 返回类型 = 签名.返回类型;
    节点_ RetN = .实例化(返回类型);
    if (n.类型 !is ··null!(节点_)) {
        RetN = .更新!(节点_)(RetN, n.类型);
    }
    节点数组_!(修饰符_) 修饰符 = 根据符号更新修饰符(n.符号);
    if ((n.修饰符 !is null) && (n.修饰符.原型 !is ··null!(修饰符_[])) && ((修饰符 !is null) && (修饰符.原型 !is ··null!(修饰符_[])))) {
        修饰符 = .更新节点数组!(修饰符_, 修饰符_)(修饰符, n.修饰符);
    }
    if (TZ.函数声明 is ··null!(节点_)) {
        ··Klang节点_.Klang令牌_!(KSK) 声明修饰符 = fc.转为令牌(KSK.声明_);
        节点数组_!(修饰符_) 新修饰符组 = 修饰符;
        if ((修饰符 !is null) && (修饰符.原型 !is ··null!(修饰符_[]))) {
            修饰符_[] 声明组 = [(cast(修饰符_)(声明修饰符))];
            .追加!(修饰符_)(声明组, 修饰符.原型);
            新修饰符组 = fc.f·创建节点数组!(修饰符_)(声明组, false);
        }
        else {
            新修饰符组 = fc.f·创建节点数组!(修饰符_)([(cast(修饰符_)(声明修饰符))], false);
        }
        函数声明_ xdec = fc.创建函数声明(名称, ··null!(节点数组_!(··Klang节点_.类型形参_)), 形参组, RetN, ··null!(基础节点_), 新修饰符组);
        TZ.函数声明 = xdec;
        TZ.引用标志 |= 实例化引用标志_.函数声明_;
    }
    基础节点_ 函数体 = .更新!(基础节点_)(.实例化访问语句(n.函数体), n.函数体);
    函数声明_ xn = .更新!(函数声明_)(fc.创建函数声明(名称, ··null!(节点数组_!(··Klang节点_.类型形参_)), 形参组, RetN, 函数体, 修饰符), n);
    xn.本地组 = .当前局部符号表;
    .当前局部符号表 = 储存当前局部符号表;
    TZ.函数定义 = xn;
    xn.符号 = n.符号;
    TZ.变量定义 = .变量声明组;
    TZ.引用标志 |= 实例化引用标志_.函数定义_;
    TZ.引用标志 &= ~实例化引用标志_.站位符_;
    基础节点_[] 当前 = 创建数组!(基础节点_)();
    if ((TZ.变量定义 !is ··null!(基础节点_[])) && TZ.变量定义.length > 0) {
        .追加!(基础节点_)(当前, TZ.变量定义);
    }
    .追加!(基础节点_)(当前, TZ.函数定义);
    .追加!(基础节点_)(当前未整合的源文件.语句组, 当前);
    当前未整合的源文件.文件内存在的.p·设置(name, TZ.引用标志);
    .变量声明组 = 储存变量声明组;
}
void 访问对象声明(对象声明_ n) {
    // 如果声明来自 声明文件
    符号_ 符号 = (cast(符号_)(n.符号));
    类型_ 储存符号类型 = 符号.类型;
    符号.类型 = .当前类型;
    if ((符号.标志 & 符号标志_.静态_) != 0) {
    }
    else {
        基础节点_[] 储存变量声明组 = .变量声明组;
        dstring name = 当前类型.实例化名称;
        标识符_ 名称 = .更新!(标识符_)(fc.创建文本标识符(name), n.名称);
        类型_ 基类型 = 当前类型.解析的基类;
        表达式包含类型实参_[] 继承子句成员;
        if (基类型 != 全局对象类型) {
            节点_ 基类实例化 = .实例化(基类型);
            表达式包含类型实参_ 基类名称 = fc.创建表达式包含类型实参(基类实例化);
            节点扩展_ links = 获取合成节点扩展(基类名称);
            links.解析类型 = 基类型;
            if (继承子句成员 is ··null!(表达式包含类型实参_[])) {
                继承子句成员 = 创建数组!(表达式包含类型实参_)();
            }
            .追加!(表达式包含类型实参_)(继承子句成员, 基类名称);
        }
        类型_[] 实现的接口 = 当前类型.实现的接口;
        if (实现的接口 !is ··null!(类型_[])) {
            foreach (类型_ I; 实现的接口) {
                节点_ IZ = .实例化(I);
                表达式包含类型实参_ IT = fc.创建表达式包含类型实参(IZ);
                if (继承子句成员 is ··null!(表达式包含类型实参_[])) {
                    继承子句成员 = 创建数组!(表达式包含类型实参_)();
                }
                .追加!(表达式包含类型实参_)(继承子句成员, IT);
            }
        }
        实例化引用_ TZ = .获取或初始引用实例(name);
        TZ.类型引用 = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符(name)));
        项目声明的符号集合.p·设置(name, TZ);
        TZ.引用标志 |= 实例化引用标志_.类型声明_ | 实例化引用标志_.类型定义_;
        节点扩展_ links = 获取合成节点扩展(TZ.类型引用);
        links.解析类型 = .当前类型;
        TZ.类型名称 = name;
        TZ.碎裂名称 = name;
        TZ.符号 = (cast(符号_)(n.符号));
        TZ.虚表 = 当前类型.虚表;
        TZ.类型 = .当前类型;
        继承子句_ 继承子句;
        if (继承子句成员 !is ··null!(表达式包含类型实参_[])) {
            // 继承子句
            继承子句 = .更新!(继承子句_)(fc.创建继承子句(fc.f·创建节点数组!(表达式包含类型实参_)(继承子句成员, false)), n.继承子句[0]);
        }
        访问节点数组!(节点_)(n.成员组, cast(void delegate(节点_))(·fd(&.访问类型成员)));
        节点数组_!(修饰符_) 修饰符 = 根据符号更新修饰符(n.符号);
        TZ.类型声明 = .更新!(对象声明_)(fc.创建对象声明((cast(标识符_)(名称)), fc.f·创建节点数组!(节点_)((cast(节点_[])(.当前属性组)), false), ··null!(节点数组_!(··Klang节点_.类型形参_)), (继承子句 ? fc.f·创建节点数组!(继承子句_)([继承子句], false) : ··null!(节点数组_!(继承子句_))), 修饰符), n);
        TZ.变量定义 = .变量声明组;
        TZ.虚表语句组 = .虚表语句组;
        TZ.构建及释放声明组 = .构建及释放声明组;
        TZ.引用标志 &= ~实例化引用标志_.站位符_;
        基础节点_[] 当前 = 创建数组!(基础节点_)();
        if ((TZ.变量定义 !is ··null!(基础节点_[])) && TZ.变量定义.length > 0) {
            .追加!(基础节点_)(当前, TZ.变量定义);
        }
        if (TZ.类型声明 !is ··null!(节点_)) {
            .追加!(基础节点_)(当前, TZ.类型声明);
        }
        if ((TZ.虚表语句组 !is ··null!(基础节点_[])) && TZ.虚表语句组.length > 0) {
            .追加!(基础节点_)(当前, TZ.虚表语句组);
        }
        if ((TZ.非虚语句组 !is ··null!(基础节点_[])) && TZ.非虚语句组.length > 0) {
            .追加!(基础节点_)(当前, TZ.非虚语句组);
        }
        if ((TZ.构建及释放声明组 !is ··null!(基础节点_[])) && TZ.构建及释放声明组.length > 0) {
            .追加!(基础节点_)(当前, TZ.构建及释放声明组);
        }
        当前未整合的源文件.对象声明组.p·设置(name, 当前);
        当前未整合的源文件.文件内存在的.p·设置(name, TZ.引用标志);
        .变量声明组 = 储存变量声明组;
    }
    符号.类型 = 储存符号类型;
}
void 访问结构声明(结构声明_ n) {
    符号_ 符号 = (cast(符号_)(n.符号));
    类型_ 储存符号类型 = 符号.类型;
    符号.类型 = .当前类型;
    if ((符号.标志 & 符号标志_.静态_) != 0) {
    }
    else {
        基础节点_[] 储存变量声明组 = .变量声明组;
        dstring name = 当前类型.实例化名称;
        标识符_ 名称 = .更新!(标识符_)(fc.创建文本标识符(name), n.名称);
        类型_ 基类型 = 当前类型.解析的基类;
        表达式包含类型实参_[] 继承子句成员;
        if (基类型 !is ··null!(类型_)) {
            节点_ 基类实例化 = .实例化(基类型);
            表达式包含类型实参_ 基类名称 = fc.创建表达式包含类型实参(基类实例化);
            节点扩展_ links = 获取合成节点扩展(基类名称);
            links.解析类型 = 基类型;
            if (继承子句成员 is ··null!(表达式包含类型实参_[])) {
                继承子句成员 = 创建数组!(表达式包含类型实参_)();
            }
            .追加!(表达式包含类型实参_)(继承子句成员, 基类名称);
        }
        类型_[] 实现的接口 = 当前类型.实现的接口;
        if (实现的接口 !is ··null!(类型_[])) {
            foreach (类型_ I; 实现的接口) {
                节点_ IZ = .实例化(I);
                表达式包含类型实参_ IT = fc.创建表达式包含类型实参(IZ);
                if (继承子句成员 is ··null!(表达式包含类型实参_[])) {
                    继承子句成员 = 创建数组!(表达式包含类型实参_)();
                }
                .追加!(表达式包含类型实参_)(继承子句成员, IT);
            }
        }
        实例化引用_ TZ = .获取或初始引用实例(name);
        TZ.引用标志 |= 实例化引用标志_.类型声明_ | 实例化引用标志_.类型定义_;
        TZ.类型引用 = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符(name)));
        项目声明的符号集合.p·设置(name, TZ);
        节点扩展_ links = 获取合成节点扩展(TZ.类型引用);
        links.解析类型 = .当前类型;
        TZ.类型名称 = name;
        TZ.碎裂名称 = name;
        TZ.符号 = (cast(符号_)(n.符号));
        TZ.虚表 = 当前类型.虚表;
        TZ.类型 = .当前类型;
        继承子句_ 继承子句;
        if (继承子句成员 !is ··null!(表达式包含类型实参_[])) {
            // 继承子句
            继承子句 = .更新!(继承子句_)(fc.创建继承子句(fc.f·创建节点数组!(表达式包含类型实参_)(继承子句成员, false)), n.继承子句[0]);
        }
        访问节点数组!(节点_)(n.成员组, cast(void delegate(节点_))(·fd(&.访问类型成员)));
        节点数组_!(修饰符_) 修饰符 = 根据符号更新修饰符(n.符号);
        TZ.类型声明 = .更新!(结构声明_)(fc.创建结构声明((cast(标识符_)(名称)), fc.f·创建节点数组!(节点_)((cast(节点_[])(.当前属性组)), false), ··null!(节点数组_!(··Klang节点_.类型形参_)), (继承子句 ? fc.f·创建节点数组!(继承子句_)([继承子句], false) : ··null!(节点数组_!(继承子句_))), 修饰符), n);
        TZ.变量定义 = .变量声明组;
        TZ.虚表语句组 = .虚表语句组;
        TZ.构建及释放声明组 = .构建及释放声明组;
        TZ.引用标志 &= ~实例化引用标志_.站位符_;
        基础节点_[] 当前 = 创建数组!(基础节点_)();
        if ((TZ.变量定义 !is ··null!(基础节点_[])) && TZ.变量定义.length > 0) {
            .追加!(基础节点_)(当前, TZ.变量定义);
        }
        if (TZ.类型声明 !is ··null!(节点_)) {
            .追加!(基础节点_)(当前, TZ.类型声明);
        }
        if ((TZ.虚表语句组 !is ··null!(基础节点_[])) && TZ.虚表语句组.length > 0) {
            .追加!(基础节点_)(当前, TZ.虚表语句组);
        }
        if ((TZ.非虚语句组 !is ··null!(基础节点_[])) && TZ.非虚语句组.length > 0) {
            .追加!(基础节点_)(当前, TZ.非虚语句组);
        }
        if ((TZ.构建及释放声明组 !is ··null!(基础节点_[])) && TZ.构建及释放声明组.length > 0) {
            .追加!(基础节点_)(当前, TZ.构建及释放声明组);
        }
        当前未整合的源文件.对象声明组.p·设置(name, 当前);
        当前未整合的源文件.文件内存在的.p·设置(name, TZ.引用标志);
        .变量声明组 = 储存变量声明组;
    }
    符号.类型 = 储存符号类型;
}
void 访问类型声明(类型声明_ n) {
}
void 访问接口声明(接口声明_ n) {
}
void 访问类型成员(基础节点_ n) {
    switch (n.目标种类) {
        case KSK.属性声明: {
            return .访问属性声明((cast(属性声明_)(n)));
        }
        case KSK.方法声明: {
            return .访问方法声明((cast(方法声明_)(n)));
        }
        case KSK.构建声明: {
            return .访问构建声明((cast(构建声明_)(n)));
        }
        case KSK.释放声明: {
            return .访问释放声明((cast(释放声明_)(n)));
        }
        default: break;
    }
}
void 访问释放声明(释放声明_ n) {
}
void 访问构建声明(构建声明_ n) {
    类型映射_ 储存当前映射 = cast(类型映射_)(.当前映射);
    基础节点_[] 储存变量声明组 = .变量声明组;
    签名_ sig = K.获取签名从签名声明(n);
    签名_ 签名 = K.instantiateSignature(sig, cast(类型映射_)(.当前映射), true);
    签名.标志 &= ~(cast(ulong)(签名标志_.是泛型签名_));
    dstring name = .实例化构建碎裂名(签名, 当前类型.符号);
    实例化引用_ TZ = .获取或初始引用实例(name);
    TZ.碎裂名称 = name;
    TZ.符号 = (cast(符号_)(n.符号));
    签名.碎裂名称 = name;
    符号表_ 储存当前局部符号表 = .当前局部符号表;
    .当前局部符号表 = 创建符号表();
    形参声明_[] 储存当前形参声明组 = .当前形参声明组;
    .当前形参声明组 = 创建数组!(形参声明_)();
    .添加本体形参(.当前类型名, n.符号.标志);
    节点数组_!(修饰符_) 修饰符 = 根据符号更新修饰符(n.符号);
    if ((n.修饰符 !is null) && (n.修饰符.原型 !is ··null!(修饰符_[])) && ((修饰符 !is null) && (修饰符.原型 !is ··null!(修饰符_[])))) {
        修饰符 = .更新节点数组!(修饰符_, 修饰符_)(修饰符, n.修饰符);
    }
    .实例化当前形参(签名, n);
    类型引用_ RT = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符(.当前类型名)));
    标识符_ 名称 = .更新!(标识符_)(fc.创建文本标识符(name), n.名称);
    if (TZ.函数声明 is ··null!(节点_)) {
        ··Klang节点_.Klang令牌_!(KSK) 声明修饰符 = fc.转为令牌(KSK.声明_);
        节点数组_!(修饰符_) 新修饰符组 = 修饰符;
        if ((修饰符 !is null) && (修饰符.原型 !is ··null!(修饰符_[]))) {
            修饰符_[] 声明组 = [(cast(修饰符_)(声明修饰符))];
            .追加!(修饰符_)(声明组, 修饰符.原型);
            新修饰符组 = fc.f·创建节点数组!(修饰符_)(声明组, false);
        }
        else {
            新修饰符组 = fc.f·创建节点数组!(修饰符_)([(cast(修饰符_)(声明修饰符))], false);
        }
        函数声明_ xdec = fc.创建函数声明(名称, ··null!(节点数组_!(··Klang节点_.类型形参_)), new 节点数组_!(形参声明_)(.当前形参声明组), RT, ··null!(基础节点_), 新修饰符组);
        TZ.函数声明 = xdec;
        TZ.引用标志 |= 实例化引用标志_.构建声明_;
    }
    项目声明的符号集合.p·设置(name, TZ);
    if (n.函数体 is ··null!(基础节点_)) {
        当前未整合的源文件.文件内存在的.p·设置(name, TZ.引用标志);
        .当前局部符号表 = 储存当前局部符号表;
        .当前形参声明组 = 储存当前形参声明组;
        .变量声明组 = 储存变量声明组;
        return;
    }
    bool 储存返回本体 = .返回本体;
    .返回本体 = true;
    基础节点_ 函数体 = .更新!(基础节点_)(.实例化访问语句(n.函数体), n.函数体);
    .返回本体 = 储存返回本体;
    函数声明_ 方法声明 = .更新!(函数声明_)(fc.创建函数声明(名称, ··null!(节点数组_!(··Klang节点_.类型形参_)), new 节点数组_!(形参声明_)(.当前形参声明组), RT, 函数体), n);
    方法声明.本地组 = .当前局部符号表;
    .追加!(基础节点_)(.构建及释放声明组, 方法声明);
    .当前映射 = cast(类型映射_)(储存当前映射);
    节点扩展_ links = 获取合成节点扩展(方法声明);
    links.实例化的签名 = 签名.泛型目标 ? 签名.泛型目标 : 签名;
    TZ.函数定义 = 方法声明;
    方法声明.符号 = n.符号;
    TZ.变量定义 = .变量声明组;
    TZ.引用标志 |= 实例化引用标志_.构建定义_;
    当前未整合的源文件.文件内存在的.p·设置(name, TZ.引用标志);
    TZ.引用标志 &= ~实例化引用标志_.站位符_;
    .当前局部符号表 = 储存当前局部符号表;
    .当前形参声明组 = 储存当前形参声明组;
    .变量声明组 = 储存变量声明组;
    return;
}
dstring 实例化构建碎裂名(签名_ 签名, 基础符号_ 父符号) {
    符号_ s = new 符号_((cast(ulong)(符号标志_.函数_ | 符号标志_.构建_)), 内部符号名_.新建_);
    s.值声明 = 签名.签名声明;
    s.父符号 = 父符号;
    return .实例化方法碎裂名(s, 签名);
}
void 访问属性声明(属性声明_ n) {
    符号_ 符号 = (cast(符号_)(n.符号));
    类型_ 类型 = K.instantiateType(符号.类型, cast(类型映射_)(.当前映射));
    节点_ 类型引用 = .实例化(类型);
    if ((符号.标志 & 符号标志_.静态_) != 0) {
    }
    else {
        if ((符号.标志 & 符号标志_.重载_) != 0) {
            节点_ 获取函数的语句;
            if (符号.重载的基类属性 !is ··null!(基础符号_)) {
                获取函数的语句 = fc.创建调用表达式(fc.创建标识符("基类"d), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(标识符_)([fc.创建标识符("基类"d)], false)));
            }
            else {
                获取函数的语句 = fc.创建属性访问表达式(fc.创建标识符("基类"d), n.名称);
            }
            函数声明_ getN = fc.创建函数声明(n.名称, ··null!(节点数组_!(··Klang节点_.类型形参_)), fc.f·创建节点数组!(形参声明_)([
                fc.创建形参声明(fc.创建标识符("本体"d), fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符(.当前类型名))))
            ], false), 类型引用, fc.创建块(·to!(节点数组_!(节点_))(fc.f·创建节点数组!(返回语句_)(new 节点数组_!(返回语句_)([fc.创建返回语句(获取函数的语句)])))));
            .追加!(基础节点_)(.虚表语句组, getN);
            节点_ 设置函数的语句;
            if (符号.重载的基类属性 !is ··null!(基础符号_)) {
                设置函数的语句 = fc.创建调用表达式(fc.创建标识符("基类"d), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(标识符_)([fc.创建标识符("基类"d)], false)));
            }
            else {
                设置函数的语句 = fc.创建表达式语句(fc.创建二元表达式(fc.创建属性访问表达式(fc.创建标识符("基类"d), n.名称), KSK.等号, fc.创建类型转换表达式(fc.创建标识符("V"d), /** 这里应该是基类属性的类型 */ 类型引用)));
            }
            函数声明_ setN = fc.创建函数声明(n.名称, ··null!(节点数组_!(··Klang节点_.类型形参_)), fc.f·创建节点数组!(形参声明_)([
                fc.创建形参声明(fc.创建标识符("本体"d), fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符(.当前类型名)))),
                fc.创建形参声明(fc.创建标识符("V"d), 类型引用)
            ], false), fc.转为令牌(KSK.无值_), fc.创建块(fc.f·创建节点数组!(节点_)([设置函数的语句], false)));
            .追加!(基础节点_)(.虚表语句组, setN);
        }
        else {
            节点数组_!(修饰符_) 修饰符 = 根据符号更新修饰符(符号);
            .追加!(基础节点_)(.当前属性组, .更新!(属性声明_)(fc.创建属性声明(.更新!(标识符_)(fc.创建标识符(获取符号名(符号)), n.名称), .更新!(节点_)(类型引用, n.类型), /* 初始化 */ ··null!(节点_), 修饰符), n));
        }
    }
}
void 访问方法声明(方法声明_ n) {
    if ((n.标志 & 节点标志_.是泛型声明_) == 0) {
        符号_ 符号 = K.获取类型的方法符号(.当前类型, n);
        if ((符号.标志 & 符号标志_.静态_) != 0) {
        }
        else {
            // 如果是声明文件内的 只生成 声明, 没有定义
            签名_ 签名 = K.获取类型的方法签名(.当前类型, n);
            符号表_ 储存当前局部符号表 = .当前局部符号表;
            .当前局部符号表 = 创建符号表();
            形参声明_[] 储存当前形参声明组 = .当前形参声明组;
            基础节点_[] 储存变量声明组 = .变量声明组;
            dstring name = .实例化方法碎裂名(符号, 签名);
            实例化引用_ TZ = .获取或初始引用实例(name);
            节点数组_!(修饰符_) 修饰符 = 根据符号更新修饰符(n.符号);
            if ((n.修饰符 !is null) && (n.修饰符.原型 !is ··null!(修饰符_[])) && ((修饰符 !is null) && (修饰符.原型 !is ··null!(修饰符_[])))) {
                修饰符 = .更新节点数组!(修饰符_, 修饰符_)(修饰符, n.修饰符);
            }
            节点_ RT = .实例化(签名.返回类型);
            标识符_ 名称 = .更新!(标识符_)(fc.创建文本标识符(name), n.名称);
            .当前形参声明组 = 创建数组!(形参声明_)();
            .添加本体形参(.当前类型名, 符号.标志);
            .实例化当前形参(签名, n);
            if (TZ.函数声明 is ··null!(节点_)) {
                ··Klang节点_.Klang令牌_!(KSK) 声明修饰符 = fc.转为令牌(KSK.声明_);
                节点数组_!(修饰符_) 新修饰符组 = 修饰符;
                if ((修饰符 !is null) && (修饰符.原型 !is ··null!(修饰符_[]))) {
                    修饰符_[] 声明组 = [(cast(修饰符_)(声明修饰符))];
                    .追加!(修饰符_)(声明组, 修饰符.原型);
                    新修饰符组 = fc.f·创建节点数组!(修饰符_)(声明组, false);
                }
                else {
                    新修饰符组 = fc.f·创建节点数组!(修饰符_)([(cast(修饰符_)(声明修饰符))], false);
                }
                函数声明_ xdec = fc.创建函数声明(名称, ··null!(节点数组_!(··Klang节点_.类型形参_)), new 节点数组_!(形参声明_)(.当前形参声明组), RT, ··null!(基础节点_), 新修饰符组);
                TZ.函数声明 = xdec;
                TZ.引用标志 |= 实例化引用标志_.方法声明_;
            }
            项目声明的符号集合.p·设置(name, TZ);
            if (n.函数体 is ··null!(基础节点_)) {
                当前未整合的源文件.文件内存在的.p·设置(name, TZ.引用标志);
                .当前局部符号表 = 储存当前局部符号表;
                .当前形参声明组 = 储存当前形参声明组;
                .变量声明组 = 储存变量声明组;
                return;
            }
            assert(n.函数体 !is ··null!(基础节点_), "没有函数体"c);
            基础节点_ 函数体 = .更新!(基础节点_)(.实例化访问语句(n.函数体), n.函数体);
            函数声明_ 方法声明 = .更新!(函数声明_)(fc.创建函数声明(名称, ··null!(节点数组_!(··Klang节点_.类型形参_)), new 节点数组_!(形参声明_)(.当前形参声明组), RT, 函数体), n);
            方法声明.符号 = 符号;
            方法声明.本地组 = .当前局部符号表;
            .追加!(基础节点_)(.虚表语句组, 方法声明);
            节点扩展_ links = 获取合成节点扩展(方法声明);
            links.实例化的签名 = 签名.泛型目标 ? 签名.泛型目标 : 签名;
            TZ.函数定义 = 方法声明;
            方法声明.符号 = n.符号;
            TZ.变量定义 = .变量声明组;
            TZ.引用标志 |= 实例化引用标志_.方法定义_;
            当前未整合的源文件.文件内存在的.p·设置(name, TZ.引用标志);
            TZ.引用标志 &= ~实例化引用标志_.站位符_;
            .当前局部符号表 = 储存当前局部符号表;
            .当前形参声明组 = 储存当前形参声明组;
            .变量声明组 = 储存变量声明组;
            return;
        }
    }
}
dstring 实例化方法碎裂名(基础符号_ 符号, 签名_ 签名) {
    类型_ type = K.获取符号的类型(符号);
    签名_ 储存当前需要实例化的签名 = type.当前需要实例化的签名;
    type.当前需要实例化的签名 = 签名;
    Mangler m = new Mangler();
    m.碎裂实例化类型(type);
    type.当前需要实例化的签名 = 储存当前需要实例化的签名;
    dstring chs = m.outString();
    return "\\01_D"d ~ chs;
}
void 添加本体形参(dstring 类名, ulong 符号标志) {
    节点_ 本体类型 = 项目声明的符号集合.获取(类名).类型引用;
    if ((符号标志 & (cast(ulong)((符号标志_.只读_ | 符号标志_.恒定_ | 符号标志_.共享_)))) != 0) {
        ulong 标志 = (符号标志 & (cast(ulong)((符号标志_.只读_ | 符号标志_.恒定_ | 符号标志_.共享_))));
        if ((标志 & 符号标志_.恒定_) != 0) {
            本体类型 = fc.创建类型限定类型(KSK.恒定_, 本体类型);
        }
        else if ((标志 & 符号标志_.共享_) != 0) {
            if ((标志 & 符号标志_.只读_) != 0) {
                本体类型 = fc.创建类型限定类型(KSK.共享_, fc.创建类型限定类型(KSK.只读_, 本体类型));
            }
            else {
                本体类型 = fc.创建类型限定类型(KSK.共享_, 本体类型);
            }
        }
        else if ((标志 & 符号标志_.只读_) != 0) {
            本体类型 = fc.创建类型限定类型(KSK.只读_, 本体类型);
        }
    }
    获取合成节点扩展(本体类型).解析类型 = .当前类型;
    符号_ 本体符号 = new 符号_((cast(long)(符号标志_.形参声明_)), "本体"d);
    本体符号.类型 = .当前类型;
    当前局部符号表.p·设置("本体"d, 本体符号);
    形参声明_ 本体形参声明 = fc.创建形参声明(fc.创建标识符("本体"d), 本体类型);
    本体形参声明.符号 = 本体符号;
    .追加!(形参声明_)(.当前形参声明组, 本体形参声明);
}
void 实例化当前形参(签名_ 签名, 签名声明_ n) {
    {
        for (int i = 0; i < 签名.形参声明组.length; ++i) {
            符号_ p = 签名.形参声明组[i];
            类型_ pt = K.获取符号的类型(p);
            形参声明_ np = n.形参组[i];
            节点数组_!(修饰符_) 修饰符 = 根据符号更新修饰符(p);
            if ((np.修饰符 !is null) && (np.修饰符.原型 !is ··null!(修饰符_[])) && ((修饰符 !is null) && (修饰符.原型 !is ··null!(修饰符_[])))) {
                修饰符 = .更新节点数组!(修饰符_, 修饰符_)(修饰符, np.修饰符);
            }
            基础节点_ init;
            if (np.初始化 !is ··null!(节点_)) {
                init = .更新!(基础节点_)(.访问表达式(np.初始化), np.初始化);
            }
            形参声明_ pd = fc.创建形参声明(np.名称, .更新!(节点_)(.实例化(pt), np.类型), 修饰符, np.问号, (cast(节点_)(init)));
            pd.符号 = p;
            assert(!当前局部符号表.具有(p.名称), "符号重复了"c);
            当前局部符号表.p·设置(p.名称, p);
            .追加!(形参声明_)(.当前形参声明组, .更新!(形参声明_)(pd, np));
        }
    }
}
基础节点_ 实例化访问语句(基础节点_ n) {
    return .访问语句(n);
}
基础节点_ 访问语句(基础节点_ n) {
    switch (n.目标种类) {
        case KSK.如果语句: {
            return .访问如果语句((cast(如果语句_)(n)));
        }
        case KSK.断言语句: {
            return .访问断言语句((cast(断言语句_)(n)));
        }
        case KSK.块: {
            return .访问普通块语句((cast(块_)(n)));
        }
        case KSK.表达式语句: {
            return .访问表达式语句((cast(表达式语句_)(n)));
        }
        case KSK.版本语句: {
            return .访问局部版本语句((cast(版本语句_)(n)));
        }
        case KSK.返回语句:
        case KSK.抛出语句: {
            return .访问终结语句(n);
        }
        case KSK.函数声明: {
            return .访问内部函数声明((cast(函数声明_)(n)));
        }
        default: break;
    }
    return 返回空();
}
函数声明_ 访问内部函数声明(函数声明_ n) {
    return n;
}
基础节点_ 访问局部版本语句(版本语句_ n) {
    节点扩展_ links = 获取节点扩展(n.表达式);
    if (links.计算的版本表达式 == 三元结果_.真_) {
        .不设置当前块 = true;
        .访问语句(n.然后语句);
    }
    else if (n.否则语句 !is ··null!(节点_)) {
        .不设置当前块 = true;
        .访问语句(n.否则语句);
    }
    return ··null!(基础节点_);
}
基础节点_ 访问表达式语句(表达式语句_ n) {
    基础节点_ xn = .访问表达式(n.表达式);
    if (xn !is ··null!(基础节点_)) {
        return .更新!(表达式语句_)(fc.创建表达式语句((cast(节点_)(xn))), n);
    }
    return ··null!(基础节点_);
}
基础节点_ 访问普通块语句(块_ n) {
    节点数组_!(节点_) 语句组 = (cast(块_)(n)).语句组;
    if (.不设置当前块) {
        {
            for (int i = 0; i < 语句组.length; ++i) {
                节点_ zn = 语句组[i];
                基础节点_ nn = .访问语句(zn);
                if (nn !is ··null!(基础节点_)) {
                    .追加!(基础节点_)(.当前语句组, nn);
                }
                if (.应该结束当前块) {
                    break;
                }
            }
        }
        return 返回空();
    }
    else {
        基础节点_[] 储存当前语句组 = .当前语句组;
        .当前语句组 = 创建数组!(基础节点_)();
        符号表_ 储存当前局部符号表 = .当前局部符号表;
        if ((n.标志 & 节点标志_.是容器块) != 0) {
            .当前局部符号表 = 创建符号表();
        }
        {
            for (int i = 0; i < 语句组.length; ++i) {
                节点_ zn = 语句组[i];
                基础节点_ nn = .访问语句(zn);
                if (nn !is ··null!(基础节点_)) {
                    .追加!(基础节点_)(.当前语句组, nn);
                }
                if (.应该结束当前块) {
                    break;
                }
            }
        }
        if (.返回本体) {
            if (当前语句组.length == 0) {
                返回语句_ 返回语句 = fc.创建返回语句(fc.创建符号引用表达式(fc.创建标识符("本体"d)));
                .追加!(基础节点_)(.当前语句组, 返回语句);
            }
            else {
                基础节点_ 最后一个语句 = 当前语句组[当前语句组.length - 1];
                if (最后一个语句.目标种类 != KSK.返回语句) {
                    返回语句_ 返回语句 = fc.创建返回语句(fc.创建符号引用表达式(fc.创建标识符("本体"d)));
                    .追加!(基础节点_)(.当前语句组, 返回语句);
                }
            }
        }
        块_ 块 = fc.创建块(fc.f·创建节点数组!(节点_)((cast(节点_[])(.当前语句组)), false), ··null!(节点数组_!(修饰符_)), ··null!(··klang类型_.版本容器块种类_), true);
        // 这里已经结束 直接设置初始值;
        .应该结束当前块 = false;
        if ((n.标志 & 节点标志_.是容器块) != 0) {
            块.本地组 = .当前局部符号表;
            .当前局部符号表 = 储存当前局部符号表;
        }
        .当前语句组 = 储存当前语句组;
        return 块;
    }
}
基础节点_ 访问如果语句(如果语句_ n) {
    if ((n.标志 & 节点标志_.是静态的_) != 0) {
        bool 储存不设置当前块 = .不设置当前块;
        .不设置当前块 = true;
        bool 结果 = K.计算类型断言表达式(n.表达式, cast(类型映射_)(.当前映射));
        if (结果) {
            .访问语句(n.然后语句);
        }
        else if (n.否则语句 !is ··null!(节点_)) {
            .访问语句(n.否则语句);
        }
        储存不设置当前块 = 储存不设置当前块;
        return ··null!(基础节点_);
    }
    节点_ 表达式 = (cast(节点_)(.访问表达式(n.表达式)));
    节点_ 然后语句 = (cast(节点_)(.访问语句(n.然后语句)));
    节点_ 否则语句;
    if (n.否则语句 !is ··null!(节点_)) {
        否则语句 = (cast(节点_)(.访问语句(n.否则语句)));
    }
    return .更新!(如果语句_)(fc.创建如果语句(表达式, 然后语句, 否则语句), n);
}
基础节点_ 访问断言语句(断言语句_ n) {
    节点扩展_ links = 获取节点扩展(n);
    if (links.计算的版本表达式 == 三元结果_.真_) {
        节点_[] 实参组 = 创建数组!(节点_)();
        {
            for (int i = 0; i < n.实参组.length; ++i) {
                .追加!(节点_)(实参组, (cast(节点_)(.访问表达式(n.实参组[i]))));
            }
        }
        return .更新!(断言语句_)(fc.创建断言语句(fc.f·创建节点数组!(节点_)(实参组, false)), n);
    }
    return ··null!(基础节点_);
}
基础节点_ 访问终结语句(基础节点_ n) {
    .应该结束当前块 = true;
    switch (n.目标种类) {
        case KSK.返回语句: {
            return .访问返回语句((cast(返回语句_)(n)));
        }
        case KSK.抛出语句:
        case KSK.继续语句:
        case KSK.跳出语句: {
            return n;
        }
        default: break;
    }
    return 返回空();
}
基础节点_ 访问返回语句(返回语句_ n) {
    节点_ 表达式;
    if (n.表达式 !is ··null!(节点_)) {
        基础节点_ xn = .访问表达式(n.表达式);
        if (xn !is ··null!(基础节点_)) {
            表达式 = (cast(节点_)(xn));
        }
    }
    else if (.返回本体) {
        return .更新!(返回语句_)(fc.创建返回语句(fc.创建符号引用表达式(fc.创建标识符("本体"d))), n);
    }
    return .更新!(返回语句_)(fc.创建返回语句(表达式), n);
}
基础节点_ 访问表达式(基础节点_ n) {
    switch (n.目标种类) {
        case KSK.调用表达式: {
            return .访问调用表达式((cast(调用表达式_)(n)));
        }
        case KSK.新建表达式: {
            return .访问新建表达式((cast(新建表达式_)(n)));
        }
        default: break;
    }
    return n;
}
基础节点_ 访问新建表达式(新建表达式_ n) {
    签名_ sig = 获取节点扩展(n).解析的签名;
    assert(sig !is ··null!(签名_), "没有解析签名"c);
    if ((sig.标志 & 签名标志_.是内置类型构建_) != 0) {
    }
    else if ((sig.标志 & 签名标志_.是默认构建_) != 0) {
    }
    else if ((sig.标志 & 签名标志_.是拷贝构建_) != 0) {
    }
    else {
        类型映射_ 当前 = cast(类型映射_)(.当前映射);
        if (当前 !is ··null!(类型映射_)) {
            if (sig.类型映射 !is ··null!(类型映射_)) {
                当前 = combineTypeMappers(cast(类型映射_)(当前), sig.类型映射);
            }
            sig = K.instantiateSignature(sig, cast(类型映射_)(当前));
        }
        else if (sig.类型映射 !is ··null!(类型映射_)) {
            当前 = sig.类型映射;
        }
        sig.标志 &= ~(cast(ulong)(签名标志_.是泛型签名_));
        类型_ 返回类型 = sig.返回类型;
        bool 是类类型 = (返回类型.复合标志 & 复合标志_.类_) != 0;
        类型映射_ 储存当前映射 = 返回类型.映射;
        返回类型.映射 = cast(类型映射_)(当前);
        类型引用_ RT = (cast(类型引用节点_)(.实例化(返回类型)));
        返回类型.映射 = cast(类型映射_)(储存当前映射);
        符号_ 返回类型符号 = (cast(符号_)(返回类型.符号));
        类型_ 储存类型 = 返回类型符号.类型;
        返回类型符号.类型 = 返回类型;
        dstring name = .实例化构建碎裂名(sig, 返回类型符号);
        if (!当前未整合的源文件.需要引用的.具有(name)) {
            当前未整合的源文件.需要引用的.p·设置(name, 实例化引用标志_.构建声明_);
        }
        dstring 类型名 = 返回类型.实例化名称;
        if (!当前未整合的源文件.需要引用的.具有(类型名)) {
            当前未整合的源文件.需要引用的.p·设置(类型名, 实例化引用标志_.类型声明_);
        }
        返回类型符号.类型 = 储存类型;
        标识符_ 名称 = .更新!(标识符_)(fc.创建文本标识符(name), n.类型);
        基础节点_[] args = 创建数组!(基础节点_)();
        foreach (节点_ arg; n.实参组) {
            .追加!(基础节点_)(args, .更新!(基础节点_)(.访问表达式(arg), arg));
        }
        dstring 分配函数名称 = 是类类型 ? "_d_allocclass"d : "_d_newitemT"d;
        .实例化(K.创建虚拟外部函数(分配函数名称));
        标识符_ 变量名称 = fc.创建文本标识符(.创建临时标识符(获取符号名(返回类型.符号) ~ "_init"d));
        变量语句_ 本体声明 = fc.创建变量声明语句(fc.创建变量声明(变量名称, RT));
        .追加!(基础节点_)(.当前语句组, 本体声明);
        调用表达式_ n本体 = fc.创建调用表达式(fc.创建标识符(分配函数名称), new 节点数组_!(节点_)([fc.创建符号引用表达式(变量名称)]));
        args = .追加!(基础节点_)([n本体], args);
        调用表达式_ xn = .更新!(调用表达式_)(fc.创建调用表达式(名称, fc.f·创建节点数组!(节点_)((cast(节点_[])(args)), false)), n);
        return xn;
    }
    return n;
}
调用表达式_ 访问调用表达式(调用表达式_ n) {
    签名_ sig = 获取节点扩展(n).解析的签名;
    assert(sig !is ··null!(签名_), "没有解析签名"c);
    类型映射_ 当前 = cast(类型映射_)(.当前映射);
    if (当前 !is ··null!(类型映射_)) {
        if (sig.类型映射 !is ··null!(类型映射_)) {
            当前 = combineTypeMappers(cast(类型映射_)(当前), sig.类型映射);
        }
        sig = K.instantiateSignature(sig, cast(类型映射_)(当前));
    }
    else if (sig.类型映射 !is ··null!(类型映射_)) {
        当前 = sig.类型映射;
    }
    sig.标志 &= ~(cast(ulong)(签名标志_.是泛型签名_));
    if ((sig.标志 & 签名标志_.是方法签名_) != 0) {
        if ((sig.标志 & 签名标志_.是静态签名_) != 0) {
        }
        else if ((sig.标志 & 签名标志_.是虚表签名_) != 0) {
        }
        else {
        }
    }
    else if ((sig.标志 & 签名标志_.isNewCall) != 0) {
        sig.标志 &= ~(cast(ulong)(签名标志_.是泛型签名_));
        类型_ 返回类型 = sig.返回类型;
        类型映射_ 储存类型映射 = 返回类型.映射;
        返回类型.映射 = cast(类型映射_)(当前);
        类型引用_ RT = (cast(类型引用节点_)(.实例化(返回类型)));
        返回类型.映射 = cast(类型映射_)(储存类型映射);
        符号_ 返回类型符号 = (cast(符号_)(返回类型.符号));
        类型_ 储存类型 = 返回类型符号.类型;
        返回类型符号.类型 = 返回类型;
        dstring name = .实例化构建碎裂名(sig, 返回类型符号);
        if (!当前未整合的源文件.需要引用的.具有(name)) {
            当前未整合的源文件.需要引用的.p·设置(name, 实例化引用标志_.构建声明_);
        }
        dstring 类型名 = 返回类型.实例化名称;
        if (!当前未整合的源文件.需要引用的.具有(类型名)) {
            当前未整合的源文件.需要引用的.p·设置(类型名, 实例化引用标志_.类型声明_);
        }
        返回类型符号.类型 = 储存类型;
        标识符_ 名称 = .更新!(标识符_)(fc.创建文本标识符(name), n.表达式);
        基础节点_[] args = 创建数组!(基础节点_)();
        foreach (节点_ arg; n.实参组) {
            .追加!(基础节点_)(args, .更新!(基础节点_)(.访问表达式(arg), arg));
        }
        标识符_ 变量名称 = fc.创建文本标识符(.创建临时标识符(获取符号名(返回类型.符号) ~ "_init"d));
        变量语句_ 本体声明 = fc.创建变量声明语句(fc.创建变量声明(变量名称, RT));
        .追加!(基础节点_)(.当前语句组, 本体声明);
        args = .追加!(基础节点_)([fc.创建符号引用表达式(变量名称)], args);
        调用表达式_ xn = .更新!(调用表达式_)(fc.创建调用表达式(名称, fc.f·创建节点数组!(节点_)((cast(节点_[])(args)), false)), n);
        return xn;
    }
    else {
        // 是函数调用
        类型_ 表达式类型 = K.检查表达式(n.表达式);
        签名_ 储存当前签名 = 表达式类型.当前需要实例化的签名;
        表达式类型.当前需要实例化的签名 = sig;
        类型映射_ 储存映射 = 表达式类型.映射;
        表达式类型.映射 = cast(类型映射_)(当前);
        类型引用_ 表达式的类型声明 = (cast(类型引用节点_)(.实例化(表达式类型)));
        表达式类型.映射 = cast(类型映射_)(储存映射);
        标识符_ 表达式名称 = 表达式的类型声明.类型名称.右侧;
        dstring name = 表达式名称.标识符.内容;
        if (!当前未整合的源文件.需要引用的.具有(name)) {
            当前未整合的源文件.需要引用的.p·设置(name, 实例化引用标志_.函数声明_);
        }
        基础节点_[] args = 创建数组!(基础节点_)();
        foreach (节点_ arg; n.实参组) {
            .追加!(基础节点_)(args, .更新!(基础节点_)(.访问表达式(arg), arg));
        }
        调用表达式_ xn = .更新!(调用表达式_)(fc.创建调用表达式(表达式名称, fc.f·创建节点数组!(节点_)((cast(节点_[])(args)), false)), n);
        表达式类型.当前需要实例化的签名 = 储存当前签名;
        return xn;
    }
    return n;
}
T 更新(T)(T node, 源映射范围_ re = ··null!(源映射范围_)) {
    return 设置源映射!(T)(.当前源文件, node, re);
}
节点数组_!(T) 更新节点数组(T, U)(T[] node, U[] re) {
    long 长度 = 最小(node.length, re.length);
    T[] 更新的 = 创建数组!(T)();
    {
        for (int i = 0; i < 长度; ++i) {
            .追加!(T)(更新的, .更新!(T)(node[i], re[i]));
        }
    }
    return fc.f·创建节点数组!(T)(更新的, false);
}
实例化引用_ 获取或初始引用实例(dstring name) {
    实例化引用_ TZ;
    if (项目声明的符号集合.具有(name)) {
        TZ = 项目声明的符号集合.获取(name);
    }
    else {
        TZ = new 实例化引用_();
        TZ.引用标志 |= 实例化引用标志_.站位符_;
    }
    return TZ;
}
dstring 创建临时标识符(dstring name = ""d) {
    dstring delegate(dstring) 生成;
    dstring 生成·func(dstring str) {
        if (当前局部符号表.具有(str)) {
            str ~= "_"d;
            生成(str);
        }
        return str;
    }
    生成 = &生成·func;
    if (name == ""d) {
        name = "temp"d;
    }
    return 生成(name);
}
节点_ 实例化(类型_ 类型) {
    bool 需要恢复 = false;
    if ((当前打印环境.标志 & 类型打印标志_.生成全局站位符_) == 0) {
        当前打印环境.标志 |= 类型打印标志_.生成全局站位符_;
        需要恢复 = true;
    }
    节点_ T = 实例化类型(类型, .当前打印环境);
    if (T.目标种类 == KSK.类型引用) {
        dstring name = (cast(类型引用节点_)(T)).类型名称.右侧.标识符.内容;
        if (!当前未整合的源文件.需要引用的.具有(name)) {
            assert(项目声明的符号集合.具有(name), "实例化失败"c);
            实例化引用_ TZ = 项目声明的符号集合.获取(name);
            if ((TZ.引用标志 & 实例化引用标志_.类型声明_) != 0) {
                当前未整合的源文件.需要引用的.p·设置(name, 实例化引用标志_.类型声明_);
            }
            if ((TZ.引用标志 & 实例化引用标志_.函数声明_) != 0) {
                当前未整合的源文件.需要引用的.p·设置(name, 实例化引用标志_.函数声明_);
            }
            if ((TZ.引用标志 & 实例化引用标志_.构建声明_) != 0) {
                当前未整合的源文件.需要引用的.p·设置(name, 实例化引用标志_.构建声明_);
            }
            if ((TZ.引用标志 & 实例化引用标志_.方法声明_) != 0) {
                当前未整合的源文件.需要引用的.p·设置(name, 实例化引用标志_.方法声明_);
            }
            if ((TZ.引用标志 & 实例化引用标志_.变量声明_) != 0) {
                当前未整合的源文件.需要引用的.p·设置(name, 实例化引用标志_.变量声明_);
            }
        }
    }
    if (需要恢复) {
        当前打印环境.标志 &= ~类型打印标志_.生成全局站位符_;
    }
    return T;
}
